COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	more on undefined and scott's logic
C00016 ENDMK
C⊗;
more on undefined and scott's logic

ADD CONTINUATIONS..

TRY FOR || BETWEEN OLD EVAL, NEW EVAL GENERIC AND ACTORS

in section of λ-notation:  note that <= is NOT assignment
for  fact <= λ[[x][ ... T→*[x,fact[x-1]]] would say use fact on RHS
in assigning  to LHS, and THAT IS WRONG! <= is fixed point.
c.f.  x ← -(2x+1)/x and x = -(2x+1)/x. first has value dependent on current value
of x. second has SOLUTION of x=1. so to with fact above; it has solution, but
here solution is a function rather than a simple value.
introduce through example:
	g←λy.y+1
	f←λx.g[x]
	whats f[2]
	g←λy.y-1
	what's f[2]
1. if doesn't change, then try fact.lose.
2. if does change lose closures.

Quam's suggestions:
1. re tracing and debugging: hack similar ro value cells where sube/fsubr link is
immovable and we pushj through it.

2. more hhs on bignums

what the fuck does abstract data structure mean.
perhaps consider following: definition of lists in LISP wrt to
UR of dp's. input: recog (a b); output: how to print; reognizer: islist;
how to generate; how to select: n(th); 1-4 via SDIO; 1-2 external; 3-5 internal.


look at old 7090 lisp compr

add abstract compiler

		*note in sdio and in debugging sdio's importance for debugging
		*you can read it!!

		*another reason for removing go to and label. when writing a smart compiler
		*much can be saved by remembering what is where(in which ac's] note
		*how much of lisp complier is getting registers set up.
		*code at label can be approached from any go to. so we must try
		*to remember whether every approach has same setting of reg; only then can we
		*optimize; give example; remove go to and label and problem goes away.


DEEP BINDING COMPILER !!!!! AND PROOF A'LA LONDON
    NOTE THAT DEEP BIN COMP HAS NAMES ON STACK SHALL DOESN'T..BUT CAN BE FIXED
    GOOD FOR DEBUGGING

NOTE FUNCTION WILL COMPILE CODE USUSALLY WHEREAS QUOTE WON'T.

		*ABSTRACT EVAL AND CO  SHOWING FUNARG AS PER WEIZENBAUM

		**arg about deep binding and searching stack: loop is expensive ; 
		**therefore another reason to keep iteration in language and away from programmer
		**(i.e. no go to's) since then  can be "smart" about access....should be
		**able to do something about  "fast memory" in such case

arg two: bobrow's claim that functon names are global; if i reassign defintion
for function, say "car" it is local in strongest sense rather than global.

add syntax of progs

		*somewhere...we shall be interested in ideas not coding tricks

section on types of binding perhaps: value, ref, uneval , name, ...AND BINDING
  BY PATTERN: PDI

bruce's comments
		*1. say what "undefined" means in implementation
		*    should ref implementation when undefined is first mentioned, but put later
		**2. separation of rep from algorithm
3. doesn't like special forms.. justify
4. more examples of func. args.  show lossage on closure.
		*5. doesn't like shallow binding and func. args.
6. circularity and d.scott
		*7. handling of calling w.o. ac's i.e. 1.5 imp
8. non-trivial for g.c. to search bps....true
9. wants hacks in bbn lisp exposed
10. suggest some kind of indirection for callin function args..prob poor
11. doesn't believe bit map necessary for more complex data structure marking.
12. moron dope vector

check basel on free vars in procedure assignments

		*check if we have noted that outlawing globals woulf f.u. function names
		*(which ARE  globals)

		*add  handling of funargs with shallow binder in binding revisited.

		*add selectq as a prob compare to case statement

		* on function v.s. form cf. λ[]x+y  vs x+y
ON CLOSED VS OPEN

		*ALTERNATIVE CALLING IN STACK RATHER THAN AC'S

		**note on SM-eval: if car of form is not atomic then it is assumed to be
		**reducible to a function (NOT fexpr) i.e. it evals arg. tsk,tsk.
		**related problem: can eval and co. be changed to not be so precipitous about
		**evaluating args.
		**then there's the nlambda horse shit....

hlisp eval with types

		**but in explicit discussion of functions: fixed # of args in definition and call
		**in fact  in section showing equal[A;A] or what ever

		**probelm:  predecessor 

		**explicit thaat f[a1; ...an] is apply[F a1' ....an'; st of a	ll called non prim funcst]

should show explicitly stack picture of returns on stack
do in parallel with coutour...i.e. in columns

		*(LAMBDA(LAMBDA) ...) AFTER NEW SYM TAB 
		*OR  prog[x;y]    ......x← y;    x:      ....go [x]
		*either of above for multiplcity of props.

NEED SECTION ON READ HACKERY...INTERN READLIST  EXPLODE

		*EXTENSIVE SECTIONS ON BINDING SHALLOW DEEP HACKERY

EXTENSIONS OF LISP A LA PLANNER DATA BASES PATT MATCH..
PATTERN DIRECTED INNVOC

		*WEIZENBAUM ON CONTROL BOBROW-WEG

MAPPING OF CONTOUR TO STACK MODEL

MACHINES 

		*QUAMS SDIO MLISP2  H.S.


how about multiple values reutrnrd s.t. function with mult args can get

shoW eval doesn't have to search oblist to find atom..done by read

		**MOVE FEXPR-MACRO SECTION TO AREA OF SM-EVAL

		**PROBLEM OF DIRECT REVERS W.O. APPEND

		add function-form distinction in λ-expr section
		
		put cross ref to form where bnf is described  for form

		COMMENT: ADD BOYER-MOORE TO PROOF SECTION, AND BIBLIO

PROBLEM IN 3.9 VALUE IN SYMTAB

		IN MACRO: WHY BETTER THAN SUBR...MORE EFFICIENT OPEN CODED BUT CAN
		BE INTUITIVE NOTATION...CF POLY EXAMPLE

		**PROBLEM IN DIFF SECTION : EXTEND TO N-ARY OPS

COMMENT: SAY "IF ARGS ARE ATOMIC..." WE REALLY MEAN "IF VALUE OF ARGS IS ATOMIC...."

		**COMMENT CAR CDR ARE SELECTORS; CONS IS CONSTRUCTOR

PROBLEM: GIVE CAR-CDR TO FIND ATOM IN..


		IN INT NOTES IN 4 SECTIONS: LANG,EVAL,IMP,COMP

ADD FANCY DIFFERENTIATION AFTTER FUN ARGS

		**ADD J. MORRIS EXAMPLE IN PROBLEMS CONCERNING COND AND ORDER
		OF EVAL

		**in list section: cons[x list] (x,    )

		add bumpfh about relative spped and space of compilation .: why not
		compile.. debugging editing...etc.

add problems on efficient compilation,using open car and cdr

		**get going on bibliography

		**ADD PROB OF EVAL FOR CALL BY NAME

IMPLICATIONS OF LISP TO OTHER LANGUAGES  COMPILING BETTER SINCE
MUCH KNOWN AT COMPILE TIME ETC. PARISNG  ETC

		**bootstrapping for chrissakes!!!!!

		**add problem in applic. of rpacac  for ratom

		**reference counters

		**crap on committee effect

notes on c e quote from test

		**define FEXPR, SUBR, EXPR FSUBR 

		*PICTURES .STRUCTURE OF FACT
		*	OBLIST
		*	NIL
		*	BIN AND UNBIND
		*	AMBIT GC
		* 	AMBIT PRIMITIVES

		**tiltle super lisp to be published by mung,manure and sun, the organic pub  co.

		**explain NIl vs evwrything else in cestrin on implemenasion--where eq x;x is given

		** problem for rplacd: rplacd x;cdr x is?

		**PROB INPROGS: EXTEND EVAL TO PROG

		**prob in progs extensions a la muddle conniver
		initialization of aux; optional, tuple eval unevaled args
		check if micro-plnr allows initialized aux.

		**much more on lambdda and internal lambdas and uses.

		**add arrays

fart with funarg and functional args: weizenbaum
INCLUDE MULTIPLE OBLISTS HERE ON S.T. DISCUSSION
note collision problem of say compiler loacals with user thus muli sym.

		**add BNF for functions near front

		**add fexpr-fsubr discussion in new eval and into discussion of how to compile

		**MORE ON NUMBERS IN FIRST SECTION

		**ADD VALUE CELL DEPRESSION, PNAME TOO

		*add LISP version of gc a la exam to secion on AMBIT

		**add calling conventions to simple pdp-10 section 6.12

more examples on machine

		**equivalence of length reverse append

		**need to add full assembler somewhere

		**add problem of Jorge: function bringing back dotted pair of
		**info found in arbit. tree.

		**hs. on semantics added to front of  compilation hs.

		**table driven scanner and parser **table driven in progs


		**and and or into compiler?

		**add E to description of assemble

		**add C as well

		**ADD SKETCH OF COMPILATION OF F = J G(X)H(Y) 

		**multiple car-cdrs and lists 1st.2nd etc

		**hash consing

errset, catch and throw

multiple oblists

		**read muddle manual again

readlist intern

i/o channels

bbn lisp editor and debugger